package com.ddm.service.impl.webImpl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ddm.constant.MessageConstant;
import com.ddm.context.BaseContext;
import com.ddm.dto.webDTO.MarketSpDTO;
import com.ddm.entity.webEntity.MarketSp;
import com.ddm.exception.DataErrorException;
import com.ddm.mapper.MarketSpMapper;
import com.ddm.result.PageResult;
import com.ddm.service.vxService.UserService;
import com.ddm.service.webService.MarketSpService;
import com.ddm.utils.BeanCopyUtil;
import com.ddm.vo.webVo.MarketSpVO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.List;

/**
 * <p>
 *沉香课堂 服务实现类
 * </p>
 *
 * @author lwj
 * @since 2025-05-7
 */
@Slf4j
@Service
public class MarketSpServiceImpl extends ServiceImpl<MarketSpMapper, MarketSp> implements MarketSpService {

    @Autowired
    private MarketSpMapper marketMapper;
    @Autowired
    private MarketSpService mService;
    @Autowired
    private UserService userService;
//    @Override
//    public Result<Market> getById(Long id) {
//        Market market = baseMapper.selectById(id);
//        return market != null ? Result.success(market) : Result.error("记录不存在");
//    }
//
//    @Override
//    public Result<Boolean> saveMarket(Market market) {
//        boolean success = save(market);
//        return success ? Result.success(true) : Result.error("保存失败");
//    }
//
//    @Override
//    public Result<Boolean> updateMarket(Market market) {
//        boolean success = updateById(market);
//        return success ? Result.success(true) : Result.error("更新失败");
//    }
//
//    @Override
//    public Result<Boolean> deleteById(Long id) {
//        boolean success = removeById(id);
//        return success ? Result.success(true) : Result.error("删除失败");
//    }



    /**
     * 插入市场供求信息列表,根据用户类型筛选，0为普通用户每天可插入一条，1为管理员无限制，2是收费用户每天可插入5条，3是vip用户无限制
     * @param mDTO
     * @return
     */
    @Override
    public String InsertSpByUserType(MarketSpDTO mDTO) {
        // 从上下文获取当前用户ID

        Long userId = BaseContext.getCurrentId();
        log.info("当前发布供求用户ID: {}", userId);

        // 查询用户类型
        Integer userType = userService.getUserTypeById(userId);

        // 计算今日日期范围
        LocalDate today = LocalDate.now();
        LocalDateTime startOfDay = today.atStartOfDay();
        LocalDateTime endOfDay = today.atTime(LocalTime.MAX);

        // 检查用户今日已插入的记录数
        LambdaQueryWrapper<MarketSp> countWrapper = new LambdaQueryWrapper<>();
        countWrapper.eq(MarketSp::getUserId, userId)
                .ge(MarketSp::getSdPublishDate, startOfDay)
                .le(MarketSp::getSdPublishDate, endOfDay);

        int todayInsertCount = mService.count(countWrapper);

        // 根据用户类型判断是否允许插入
        if (userType == 0 && todayInsertCount >= 1) {
            throw new DataErrorException(MessageConstant.ERROR_COMMON_USER_DAY_LIMIT);
        } else if (userType == 2 && todayInsertCount >= 5) {
            throw new DataErrorException(MessageConstant.ERROR_COMMON_USER2_DAY_LIMIT);
        }
        mDTO.setUserId(userId);
        MarketSp m = BeanCopyUtil.BeanCopy(mDTO, MarketSp.class);

        // 设置发布日期为当前时间
        m.setSdPublishDate(LocalDateTime.now());

       mService.save(m); // 假设这里数据库实际插入成功
                return "插入成功";
    }

    /**
     * 查询供求信息
     * @param Dto
     * @return
     */
    @Override
    public PageResult getMarketSpList(MarketSpDTO Dto) {

        LambdaQueryWrapper<MarketSp> queryWrapper = new LambdaQueryWrapper<>();
        Page<MarketSp> mPage = new Page(Dto.getPage() , Dto.getPageSize());
        queryWrapper.orderByAsc(MarketSp::getSdPublishDate);
        // 模糊查询条件：对 aTitle、aPublishMan、aAbstract 字段做模糊匹配
        String keyword = Dto.getKey();
        if (keyword != null && !keyword.trim().isEmpty()) {
            queryWrapper.like(MarketSp::getSdTitle, keyword)
                    .or()
                    .like(MarketSp::getSdMan, keyword);

        }


        List<MarketSp> records = mService.page(mPage, queryWrapper).getRecords();
        long total = mPage.getTotal();
        List<MarketSpVO> ListVos = BeanCopyUtil.BeanCopyList(records, MarketSpVO.class);
        return new PageResult(total,ListVos);
    }
//    @Override
//    public void deleteMarketSpList(List<MarketSpDTO> mDTOS) {
//        // 提取ID列表
//        List<Long> ids = mDTOS.stream()
//                .map(MarketSpDTO::getId)
//                .collect(Collectors.toList());
//
//        // 批量查询验证存在性
//        List<Market> marketList = marketMapper.selectBatchIds(ids);
//
//        // 验证所有记录都存在
//        if (marketList.size() != ids.size()) {
//            throw new DataErrorException(MessageConstant.ERROR_DATA);
//        }
//
//        // 批量删除
//        marketMapper.deleteBatchIds(ids);
//    }
//    @Override
//    public void deleteMarketAnList(List<MarketAnDTO> mDTOS) {
//        // 提取ID列表
//        List<Long> ids = mDTOS.stream()
//                .map(MarketAnDTO::getUserId)
//                .collect(Collectors.toList());
//
//        // 批量查询验证存在性
//        List<Market> marketList = marketMapper.selectBatchIds(ids);
//
//        // 验证所有记录都存在
//        if (marketList.size() != ids.size()) {
//            throw new DataErrorException(MessageConstant.ERROR_DATA);
//        }
//
//        // 批量删除
//        marketMapper.deleteBatchIds(ids);
//    }

    /**
     * 添加供求信息
     * @param dto 供求信息DTO
     * @return 添加结果
     */
    @Override
    public boolean addMarketSp(MarketSpDTO dto) {
        // 校验必填字段
        if (dto.getSdTitle() == null || dto.getSdTitle().trim().isEmpty()) {
            throw new IllegalArgumentException("供求标题(sdTitle)不能为空");
        }

        // DTO转实体类
        MarketSp marketSp = BeanCopyUtil.BeanCopy(dto, MarketSp.class);

        // 设置默认值（如果需要）
        if (marketSp.getSdPublishDate() == null) {
            marketSp.setSdPublishDate(LocalDateTime.now());
        }

        // 执行添加
         mService.save(marketSp);
        return true;
    }

    /**
     * 根据DTO中的唯一信息删除供求信息
     * @param
     * @return 删除结果
     */
    @Override
    public boolean deleteMarketSp(long id) {

        MarketSp a=mService.getById(id);
        if (a == null) {
            throw new DataErrorException(MessageConstant.ERROR_DATA);
        }
        // 执行删除
        mService.removeById(id);
        return true;
    }

    @Override
    @Transactional
    public boolean batchDeleteMarketSp(List<Long> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return false;
        }
        // 直接使用MyBatis-Plus提供的lambda方式
        return this.lambdaUpdate()
                .in(MarketSp::getId, ids)
                .remove();
    }

    @Override
    public PageResult getPassedMarketSpList(MarketSpDTO dto) {
        LambdaQueryWrapper<MarketSp> queryWrapper = new LambdaQueryWrapper<>();
        Page<MarketSp> mPage = new Page(dto.getPage() , dto.getPageSize());
        // 排序：按发布日期升序排列
        queryWrapper.orderByAsc(MarketSp::getSdPublishDate);
        // 筛选 status = 1 的数据
        queryWrapper.eq(MarketSp::getStatus, 1);

        // 模糊查询条件：对 aTitle、aPublishMan、aAbstract 字段做模糊匹配
        String keyword = dto.getKey();
        if (keyword != null && !keyword.trim().isEmpty()) {
            queryWrapper.like(MarketSp::getSdTitle, keyword)
                    .or()
                    .like(MarketSp::getSdMan, keyword);

        }
        List<MarketSp> records = mService.page(mPage, queryWrapper).getRecords();
        long total = mPage.getTotal();
        List<MarketSpVO> ListVos = BeanCopyUtil.BeanCopyList(records, MarketSpVO.class);
        return new PageResult(total,ListVos);
    }

    /**
     * 根据DTO中的唯一信息更新供求信息
     * @param dto 供求信息DTO
     * @return 更新结果
     */
    @Override
    public boolean updateMarketSp(MarketSpDTO dto) {
        // 获取ID（通过sdTitle和sdPublishDate）
        Long id = dto.getId();
        MarketSp a=mService.getById(id);
        if (a == null) {
            throw new DataErrorException(MessageConstant.ERROR_DATA);
        }
        // DTO转实体类并设置ID
        MarketSp marketSp = BeanCopyUtil.BeanCopy(dto, MarketSp.class);
        marketSp.setId(id);

        // 执行更新
         mService.updateById(marketSp);
         return true;
    }

    @Override
    public boolean pullOffMarketSp(long id,int targetStatus) {
        // 1. 根据ID查询记录
        MarketSp marketSp = mService.getById(id);
        // 2.校验目标状态是否合法（只能是null对应的标记或2，用特殊值区分null）
        // 说明：用 -1 代表要设置为null（因为int不能直接传null，需用标记值转换）
        if (targetStatus != -1 && targetStatus != 2) {
            throw new IllegalArgumentException("目标状态只能是-1（重新上架/待审核）或2（下架）");
        }
        // 3. 检查记录是否存在
        if (marketSp == null) {
            throw new RuntimeException("该记录不存在");
        }
      // 4. 检查当前状态是否已为目标状态
            String currentStatus = marketSp.getStatus();
            boolean isSameStatus = (targetStatus == -1 && currentStatus == null)
                || (targetStatus == 2 && "2".equals(currentStatus));
        if (isSameStatus) {
            String statusDesc = targetStatus == -1 ? "待审核（重新上架）" : "下架";
            log.warn("ID为{}的记录已经{}", id, statusDesc);
            return false;
        }
//        // 5.  执行状态更新操作
//        MarketSp updateEntity = new MarketSp();
//        updateEntity.setId(id);
//        // 用-1作为标记，实际存储为null（待审核）；2则直接存储为"2"（下架）
//        updateEntity.setStatus(targetStatus == -1 ? null : String.valueOf(targetStatus));
//
//        // 5. 执行更新并返回结果
//        boolean updateResult = mService.updateById(updateEntity);
        LambdaUpdateWrapper<MarketSp> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.eq(MarketSp::getId, id) // 条件：仅更新当前id的记录
                .set(MarketSp::getStatus,
                        targetStatus == -1 ? null : String.valueOf(targetStatus)); // 只更新status

        // 执行局部更新
        boolean updateResult = mService.update(updateWrapper);
        // 即使返回false，也查询一次数据库确认状态
        MarketSp updated = mService.getById(id);
        if (updated != null) {
            // 分别判断两种目标状态
            boolean statusMatch = (targetStatus == -1 && updated.getStatus() == null)
                    || (targetStatus == 2 && "2".equals(updated.getStatus()));
            if (statusMatch) {
                String statusDesc = targetStatus == -1 ? "待审核（重新上架）" : "下架";
                log.info("ID为{}的记录已成功{}", id, statusDesc);
                return true;
            } else {
                String statusDesc = targetStatus == -1 ? "待审核（重新上架）" : "下架";
                log.error("ID为{}的记录{}失败", id, statusDesc);
                return false;
            }
        }else {
            // 当更新后查询不到记录时（极端情况，如并发删除）
            log.error("ID为{}的记录更新后不存在", id);
            return false;
        }
    }

//    /**
//     * 通过sdTitle和sdPublishDate获取ID（内部辅助方法）
//     * @param dto 供求信息DTO
//     * @return 记录ID
//     */
//    private Long getIdByUniqueFields(MarketSpDTO dto) {
//        // 校验必要条件
//        if (dto.getSdMan() == null || dto.getSdPublishDate() == null) {
//            throw new IllegalArgumentException("sdMan和sdPublishDate必须同时提供");
//        }
//
//        // 构建查询条件
//        LambdaQueryWrapper<MarketSp> wrapper = new LambdaQueryWrapper<>();
//        wrapper.eq(MarketSp::getSdMan, dto.getSdMan())
//                .eq(MarketSp::getSdPublishDate, dto.getSdPublishDate());
//
//        // 查询记录
//        MarketSp marketSp = mService.getOne(wrapper);
//        if (marketSp == null) {
//            throw new DataErrorException(MessageConstant.ERROR_DATA);
//        }
//
//        return marketSp.getId();
//    }

    /**
     * 用户身份查询供求信息
     * @param dto
     * @return
     */
    @Override
    public PageResult getUserMarketSpList(MarketSpDTO dto, Integer userId) {
        LambdaQueryWrapper<MarketSp> queryWrapper = new LambdaQueryWrapper<>();
        Page<MarketSp> page = new Page<>(dto.getPage(), dto.getPageSize());

        // 固定条件：用户ID匹配 + 按发布时间排序
        queryWrapper.eq(MarketSp::getUserId, userId)
                .orderByAsc(MarketSp::getSdPublishDate);

        String keyword = dto.getKey();
        if (keyword != null && !keyword.trim().isEmpty()) {
            // 1. 拆分关键词（按空格拆分，支持多关键词）
            String[] keywordParts = keyword.trim().split("\\s+"); // 按空格分割，如"广东省 王某某"拆分为数组

            // 2. 对每个关键词，构建"或"条件（任一字段包含该关键词）
            for (String part : keywordParts) {
                // 每个关键词必须满足：（地址字段包含）OR（标题/联系人包含）
                queryWrapper.and(qw -> qw
                        // 原有字段（标题、联系人、URL）
                        .or().like(MarketSp::getSdTitle, part)
                        .or().like(MarketSp::getSdMan, part)
                        .or().like(MarketSp::getSdUrl, part)
                );
            }
        }

        // 执行查询
        Page<MarketSp> resultPage = mService.page(page, queryWrapper);
        List<MarketSpVO> voList = BeanCopyUtil.BeanCopyList(resultPage.getRecords(), MarketSpVO.class);
        return new PageResult(resultPage.getTotal(), voList);
    }
    }
